home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / nos042_s / arp.p < prev    next >
Text File  |  1993-12-28  |  62KB  |  1,961 lines
  1.  
  2. /* Address Resolution Protocol (ARP) functions. Sits between IP and
  3.  * Level 2, mapping IP to Level 2 addresses for all outgoing datagrams.
  4.  * Copyright 1991 Phil Karn, KA9Q
  5.  */
  6.  
  7. /****************************************************************************
  8. *    $Id: arp.c 1.2 93/07/16 11:41:45 ROOT_DOS Exp $
  9. *    14 Jun 93    1.2        GT    Fix warnings.                                    *
  10. *
  11. *  ATARI Version by David Nash - dnash@chaos.demon.co.uk
  12. *
  13. *  ANSI style function definitions
  14. *
  15. ****************************************************************************/
  16.  
  17. /****************************************************************************
  18. *    $Id: global.h 1.6 93/07/16 11:44:56 ROOT_DOS Exp $
  19. *    24 Aug 92    1.3        GT    Redefine time.                                    *
  20. *    13 Sep 92    1.4        GT    New file modes.                                    *
  21. *    09 May 93    1.6        GT    Fix warnings.                                    *
  22. *
  23. *  ATARI Version by David Nash - dnash@chaos.demon.co.uk
  24. *
  25. *  stdio.h and stdlib included
  26. *  shadow definitions added for fileops
  27. * 
  28. ****************************************************************************/
  29.  
  30. /* Global definitions used by every source file.
  31.  * Some may be compiler dependent.
  32.  */
  33.  
  34. /**
  35.  * $Id: stdio.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  36.  *
  37.  * ANSI I/O interface file
  38.  *
  39.  * (c) Copyright 1989, 1992, 1993 HiSoft
  40. **/
  41.  
  42. /**
  43.  * $Id: __types.h,v 1.1 1993/11/14 14:42:42 AGK Rel $
  44.  *
  45.  * Library type definitions
  46.  *
  47.  * (c) Copyright 1992, 1993 HiSoft
  48. **/
  49.  
  50. /* ANSI X3.159-1989 types */
  51. typedef long __clock_t;
  52. typedef long int __ptrdiff_t;
  53. typedef unsigned long __size_t;
  54. typedef long __time_t;
  55. typedef unsigned char __wchar_t;
  56. typedef char *__va_list;
  57.  
  58. /* ISO/IEC 9945-1:1990 types */
  59. typedef long __off_t;
  60. typedef short __nlink_t;
  61. typedef short __pid_t;
  62. typedef signed long __ssize_t;
  63. typedef unsigned short __dev_t;
  64. typedef unsigned short __gid_t;
  65. typedef unsigned short __mode_t;
  66. typedef unsigned short __uid_t;
  67. typedef unsigned long __ino_t;
  68. typedef unsigned long __sigset_t;
  69.  
  70. typedef __size_t size_t;
  71. long __regargs _CXCERR(long);        /* always __regargs for efficiency */
  72.  
  73. typedef unsigned long fpos_t;
  74.  
  75. /**
  76. *
  77. * Definitions associated with _iobuf._flag
  78. *
  79. **/
  80.  
  81. typedef struct _iobuf {
  82.     struct _iobuf *_next;
  83.     unsigned char *_ptr;    /* current buffer pointer */
  84.     int _rcnt;                /* current byte count for reading */
  85.     int _wcnt;                /* current byte count for writing */
  86.     unsigned char *_base;    /* base address of I/O buffer */
  87.     int _size;                /* size of buffer */
  88.     int _flag;                /* control flags */
  89.     int _file;                /* file descriptor */
  90.     unsigned char _cbuff;    /* single char buffer */
  91. } FILE;
  92.  
  93. extern struct _iobuf _iob[];
  94.  
  95. /*
  96.  * Prototypes for ANSI standard functions.
  97.  */
  98. int rename(const char *,const char *);
  99. long _lgscc(int,int,const char *,const char *);
  100. int remove(const char *);
  101. long _lgc(int,const char *);
  102. FILE *tmpfile(void);
  103. char *tmpnam(char *s);
  104.  
  105. int fclose(FILE *);
  106. int fflush(FILE *);
  107. FILE *fopen(const char *, const char *);
  108. FILE *freopen(const char *, const char *, FILE *);
  109. void setbuf(FILE *, char *);
  110. int setvbuf(FILE *, char *, int, size_t);
  111.  
  112. int fprintf(FILE *, const char *, ...);
  113. int fscanf(FILE *, const char *, ...);
  114. int printf(const char *, ...);
  115. int lprintf(const char *, ...);
  116. int scanf(const char *, ...);
  117. int sprintf(char *, const char *, ...);
  118. int sscanf(const char *, const char *, ...);
  119. int vfprintf(FILE *, const char *, char *);
  120. int vprintf(const char *, char *);
  121. int vsprintf(char *, const char *, char *);
  122.  
  123. int __builtin_printf(const char *, ...);
  124. int fgetc(FILE *);
  125. char *fgets(char *, int, FILE *);
  126. int fputc(int, FILE *);
  127. int fputs(const char *, FILE *);
  128. int getc(FILE *);
  129. int getchar(void);
  130. char *gets(char *);
  131. int putc(int, FILE *);
  132. int putchar(int);
  133. int puts(const char *);
  134. int ungetc(int, FILE *);
  135.  
  136. size_t fread(void *, size_t, size_t, FILE *);
  137. size_t fwrite(const void *, size_t, size_t, FILE *);
  138. int fgetpos(FILE *, fpos_t *);
  139. int fseek(FILE *, long int, int);
  140. int fsetpos(FILE *, const fpos_t *);
  141. long int ftell(FILE *);
  142. void rewind(FILE *);
  143. void clearerr(FILE *);
  144. int feof(FILE *);
  145. int ferror(FILE *);
  146. void perror(const char *);
  147.  
  148. /*
  149.  * Prototypes for Non-ANSI functions.
  150.  */
  151. int fcloseall(void);
  152. FILE *fdopen(int, const char *);
  153. int fgetchar(void);
  154. int fileno(FILE *);
  155. int flushall(void);
  156. void fmode(FILE *, int);
  157. int __stdargs _writes(char *);
  158. int _tinyprintf(char *, ...);
  159. int fputchar(int);
  160. int setnbf(FILE *);
  161. int __flushbuff(int, FILE *);
  162. FILE *fopene(const char *, const char *,char *);
  163.  
  164. FILE *popen(const char *,const char *);
  165. int    pclose(FILE *);
  166.  
  167. extern int sys_nerr;
  168. extern const char *sys_errlist[];
  169.  
  170. int unlink(const char *);
  171. char *mktemp(char *s);
  172. short fputw(int,FILE *);
  173. long fputl(long,FILE *);
  174. short fgetw(FILE *);
  175. long fgetl(FILE *);
  176.  
  177. int __getbuff(FILE *);
  178.  
  179. extern int __fmask;
  180. extern int __fmode;
  181. extern int _bufsiz;        /* default file buffer size */
  182.  
  183. /**
  184.  * $Id: stdlib.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  185.  *
  186.  * General utilities and defines
  187.  *
  188.  * (c) Copyright 1989, 1993 HiSoft
  189. **/
  190.  
  191. typedef unsigned char wchar_t;
  192. extern char __mb_cur_max;
  193.  
  194. typedef struct
  195. {
  196.     int quot;
  197.     int rem;
  198. } div_t;
  199.  
  200. typedef struct
  201. {
  202.     long int quot;
  203.     long int rem;
  204. } ldiv_t;
  205.  
  206. void *malloc(size_t);
  207. void *calloc(size_t,size_t);
  208. void *realloc(void *, size_t);
  209. void free(void *);
  210.  
  211. void *getml(size_t);
  212. int rlsml(void *, size_t);
  213. size_t sizmem(void);
  214. size_t chkml(void);
  215.  
  216. void *getmem(unsigned);
  217. int rlsmem(void *, unsigned);
  218.  
  219. void *alloca(size_t);
  220.  
  221. extern size_t _stkdelta;    /* stack/data area separation chicken factor */
  222.  
  223. void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
  224. void dqsort(double *,size_t);
  225. void fqsort(float *,size_t);
  226. void lqsort(long *,size_t);
  227. void sqsort(short *,size_t);
  228. void tqsort(char **,size_t);
  229.  
  230. int mblen(const char *,size_t);
  231. size_t mbstowcs(wchar_t *, const char *, size_t);
  232. int mbtowc(wchar_t *, const char *, size_t);
  233. size_t wcstombs(char *, const wchar_t *, size_t);
  234. int wctomb(char *, wchar_t);
  235.  
  236. void exit(int);
  237. void abort(void);
  238. int atoi(const char *);
  239. double atof(const char *);
  240. long int atol(const char *);
  241. char *getenv(const char *);
  242.  
  243. void _exit(int);
  244. void _XCEXIT(int);
  245. char *argopt(int, const char *[], const char *, int *, char *);
  246.  
  247. void *bsearch(const void *, const void *, size_t, size_t, int (*)(const void *, const void *));
  248.  
  249. void *lsearch(const void *, void *, size_t *, size_t, int (*)(const void *, const void *));
  250. void *lfind(const void *, const void *, const size_t *, size_t, int (*)(const void *, const void *));
  251.  
  252. int system(const char *);
  253. size_t _hash(const char *);
  254.  
  255. int abs(int);
  256. int __builtin_abs(int);
  257. int iabs(int);
  258. int __builtin_abs(int);
  259. long labs(long);
  260. long __builtin_labs(long);
  261. int min(int,int);
  262. int __builtin_min(int,int);
  263. int max(int,int);
  264. int __builtin_max(int,int);
  265. char *ecvt(double, int, int *, int *);
  266. char *fcvt(double, int, int *, int *);
  267. char *gcvt(double, int, char *);
  268. long getfnl(const char *, char *, size_t, int);
  269. int onexit(int(*)(int));
  270. int putenv(char *);
  271.  
  272. int rand(void);
  273. int rmvenv(const char *);
  274. void srand(unsigned int);
  275. double strtod(const char *, char **);
  276. long int strtol(const char *, char **, int);
  277. unsigned long int strtoul(const char *,char **,int);
  278. long int utpack(const char *);
  279. void utunpk(long int, char *);
  280.  
  281. int atexit(void (* )(void));
  282. div_t div(int, int);
  283. ldiv_t ldiv(long int, long int);
  284.  
  285. unsigned long _lrotl(unsigned long,int);
  286. unsigned short _rotl(unsigned int,int);
  287. unsigned long _lrotr(unsigned long,int);
  288. unsigned short _rotr(unsigned int,int);
  289. extern char *optarg;
  290. extern int optopt;
  291. extern int optind;
  292. extern int opterr;
  293. int getopt(int, char *const *, const char *);
  294.  
  295. /* These compilers require special open modes when reading binary files.
  296.  *
  297.  * "The single most brilliant design decision in all of UNIX was the
  298.  * choice of a SINGLE character as the end-of-line indicator" -- M. O'Dell
  299.  *
  300.  * "Whoever picked the end-of-line conventions for MS-DOS and the Macintosh
  301.  * should be shot!" -- P. Karn's corollary to O'Dells' declaration
  302.  */
  303. /* These two lines assume that your compiler's longs are 32 bits and
  304.  * shorts are 16 bits. It is already assumed that chars are 8 bits,
  305.  * but it doesn't matter if they're signed or unsigned.
  306.  */
  307. typedef long int32;                                /* 32-bit signed integer     */
  308. typedef unsigned short int16;                    /* 16-bit unsigned integer */
  309. typedef unsigned char byte_t;                    /*  8-bit unsigned integer */
  310. /* The "interrupt" keyword is non-standard, so make it configurable */
  311. /* Note that these definitions are on by default if none of the Turbo-C style
  312.  * memory model definitions are on; this avoids having to change them when
  313.  * porting to 68K environments.
  314.  */
  315. /* Since not all compilers support structure assignment, the ASSIGN()
  316.  * macro is used. This controls how it's actually implemented.
  317.  */
  318. /* Define null object pointer in case stdio.h isn't included */
  319. /* standard boolean constants */
  320. /* string equality shorthand */
  321. /* Extract a short from a long */
  322. /* Extract a byte from a short */
  323. /* Extract nibbles from a byte */
  324. /* Various low-level and miscellaneous functions */
  325. unsigned long availmem (void);
  326. void *callocw (unsigned nelem,unsigned size);
  327. int32 clock();
  328. int dirps (void);
  329. int htoi (char *);
  330. long htol (char *);
  331. char *inbuf (int16 port,char *buf,int16 cnt);
  332. int16 hash_ip (int32 addr);
  333. int istate (void);
  334. void log (int s,char *fmt, ...);
  335. int log2 (int16 x);
  336. void *ltop (long);
  337. void *mallocw (unsigned nb);
  338. char *outbuf (int16 port,char *buf,int16 cnt);
  339. long ptol (void *);
  340. void restore (int);
  341. void rflush (void);
  342. void rip (char *);
  343. char *smsg (char *msgs[],unsigned nmsgs,unsigned n);
  344. int tprintf (char *fmt,...);
  345. char *strdup (const char *);
  346. int wildmat (char *s,char *p,char **argv);
  347. /**
  348.  * $Id: time.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  349.  *
  350.  * ANSI/POSIX.1 Date and Time definitions
  351.  *
  352.  * (c) Copyright 1993 HiSoft
  353. **/
  354.  
  355. typedef    __clock_t clock_t;
  356. typedef    __time_t time_t;
  357. struct tm {
  358.     int tm_sec;
  359.     int tm_min;
  360.     int tm_hour;
  361.     int tm_mday;
  362.     int tm_mon;
  363.     int tm_year;
  364.     int tm_wday;
  365.     int tm_yday;
  366.     int tm_isdst;
  367. };
  368.  
  369. clock_t (clock)(void);
  370. double (difftime)(time_t, time_t);
  371. time_t (mktime)(struct tm *);
  372. time_t (time)(time_t *);
  373.  
  374. char *(asctime)(const struct tm *);
  375. char *(ctime)(const time_t *);
  376. struct tm *(gmtime)(const time_t *);
  377. struct tm *(localtime)(const time_t *);
  378. size_t (strftime)(char *, size_t, const char *, const struct tm *);
  379.  
  380. extern char *__tzname[2];
  381. extern int __daylight;
  382. extern long int __timezone;
  383. void (__tzset)(void);
  384.  
  385. void (tzset)(void);
  386. extern char *(tzname)[2];
  387. void (getclk)(unsigned char *);
  388. int (chgclk)(unsigned const char *);
  389. void (utunpk)(long, char *);
  390. long (utpack)(const char *);
  391. int (stime)(const time_t *);
  392. time_t ka9q_time (time_t *t);
  393.  
  394. /**
  395.  * $Id: stdlib.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  396.  *
  397.  * General utilities and defines
  398.  *
  399.  * (c) Copyright 1989, 1993 HiSoft
  400. **/
  401.  
  402. /**
  403.  * $Id: string.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  404.  *
  405.  * String and memory operations interface file
  406.  *
  407.  * (c) Copyright 1989, 1993 HiSoft
  408. **/
  409.  
  410. extern char _SLASH;        /* path separator character */
  411.  
  412. /*
  413.  *
  414.  * External definitions for string services
  415.  *
  416.  */
  417. char *strcat(char *, const char *);
  418. char *strchr(const char *, int);
  419. int strcmp(const char *, const char *);
  420. char *strcpy(char *, const char *);
  421. size_t strcspn(const char *, const char *);
  422. size_t strspn(const char *, const char *);
  423. size_t strlen(const char *);
  424. char *strncat(char *, const char *, size_t);
  425. int strncmp(const char *, const char *, size_t);
  426. char *strncpy(char *, const char *, size_t);
  427. char *strpbrk(const char *, const char *);
  428. char *strrchr(const char *, int);
  429. char *strstr(const char *, const char *);
  430. char *strtok(char *, const char *);
  431. char *strerror(int);
  432. int strcoll(const char *, const char *);
  433. size_t strxfrm(char *, const char *, size_t);
  434.  
  435. size_t __builtin_strlen(const char *);
  436. char *__builtin_strcpy(char *, const char *);
  437. int __builtin_strcmp(const char *, const char *);
  438.  
  439. size_t stcarg(const char *, const char *);
  440. size_t stccpy(char *to, const char *from, size_t length);
  441. char *stpcpy(char *, const char *);
  442. char *strdup(const char *);
  443. void strins(char *, const char *);
  444. char *strnset(char *, int, size_t);
  445. char *strrev(char *);
  446. size_t stcis(const char *, const char *);
  447. size_t stcisn(const char *, const char *);
  448. size_t stcpm(const char *, const char *, char **);
  449. size_t stcpma(const char *, const char *);
  450. char *stpblk(const char *);
  451. char *stpbrk(const char *, const char *);
  452. char *stpchr(const char *, int);
  453. char *stpsym(const char *, char *, size_t);
  454. char *stpchrn(const char *, int);
  455. char *stptok(const char *, char *, size_t, const char *);
  456. long strbpl(char **, size_t, const char *);
  457.  
  458. int stcgfe(char *, const char *);
  459. int stcgfn(char *, const char *);
  460. int stcd_i(const char *, int *);
  461. int stcd_l(const char *, long *);
  462. int stch_i(const char *, int *);
  463. int stch_l(const char *, long *);
  464. int stco_i(const char *, int *);
  465. int stco_l(const char *, long *);
  466. int stci_d(char *, int);
  467. int stci_h(char *, int);
  468. int stci_o(char *, int);
  469. int stcl_d(char *, long);
  470. int stcl_h(char *, long);
  471. int stcl_o(char *, long);
  472. int stcsma(char *, char *);
  473. int stcu_d(char *, unsigned);
  474. int stcul_d(char *, unsigned long);
  475.  
  476. size_t stclen(const char *);
  477. char *stpdate(char *, int, const char *);
  478. char *stptime(char *, int, const char *);
  479.  
  480. int strmid(const char *, char *, size_t, size_t);
  481. char *strlwr(char *);
  482. void strmfe(char *, const char *, const char *);
  483. void strmfn(char *, const char *, const char *, const char *, const char *);
  484. void strmfp(char *, const char *, const char *);
  485. int stcgfp(char *, const char *);
  486.  
  487. int strnicmp(const char *, const char *, size_t);
  488. int stricmp(const char *, const char *);
  489.  
  490. char *strset(char *, int);
  491. void strsfn(const char *, char *, char *, char *, char *);
  492. char *strupr(char *);
  493. int stspfp(char *, int *);
  494. void strsrt(char *[], size_t);
  495.  
  496. char *index(const char *, int);
  497. char *rindex(const char *, int);
  498. void swab(const void *,void *,size_t);
  499. /*
  500.  *
  501.  * External definitions for memory block services
  502.  *
  503.  */
  504. void *memchr(const void *, int, size_t);
  505. int memcmp(const void *, const void *, size_t);
  506. void *memcpy(void *, const void *, size_t);
  507. void *memmove(void *, const void *, size_t);
  508. void *memset(void *, int, size_t);
  509.  
  510. void *__builtin_memset(void *, int, size_t);
  511. int __builtin_memcmp(const void *, const void *, size_t);
  512. void *__builtin_memcpy(void *, const void *, size_t);
  513.  
  514. void bzero(void *, size_t);
  515. void bcopy(const void *, void *, size_t);
  516. int bcmp(const void *, const void *, size_t);
  517.  
  518. void *memccpy(void *, const void *, int, size_t);
  519. void *memswp(void *, void *, size_t);
  520. void *memrep(void *, const void *, size_t, size_t);
  521.  
  522. void setmem(void *, unsigned, int);
  523. void movmem(const void *, void *, unsigned);
  524. void repmem(const void *, void *, unsigned, unsigned);
  525. void swmem(void *, void *, unsigned);
  526. /* General purpose function macros already defined in turbo C */
  527. /* Externals used by getopt */
  528. extern int optind;
  529. extern char *optarg;
  530.  
  531. /* Threshold setting on available memory */
  532. extern int32 Memthresh;
  533.  
  534. /* System clock - count of ticks since startup */
  535. extern int32 Clock;
  536.  
  537. /* Various useful standard error messages */
  538. extern char Badhost[];
  539. extern char Nospace[];
  540. extern char Notval[];
  541. extern char *Hostname;
  542. extern char Version[];
  543.  
  544. /* Your system's end-of-line convention */
  545. extern char Eol[];
  546.  
  547. /* connect () failure timeout value. */
  548.  
  549. extern int32 connect_wait_val;
  550.  
  551. extern void (*Gcollect[])();
  552.  
  553. FILE *fopenx(const char *, const char *);
  554.  
  555. int    removex(const char *);
  556.  
  557. int    renamex(const char *, const char *);
  558.  
  559. int    openx(const char *, int, int);
  560.  
  561. int    creatx(const char *, int);
  562.  
  563. int    unlinkx(const char *);
  564.  
  565. int    accessx(const char *, int);
  566.  
  567. int    mkdirx(const char *);
  568.  
  569. /**
  570.  * $Id: stdio.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  571.  *
  572.  * ANSI I/O interface file
  573.  *
  574.  * (c) Copyright 1989, 1992, 1993 HiSoft
  575. **/
  576.  
  577. extern unsigned Ibufsize;    /* Size of interrupt buffers to allocate */
  578. extern int Nibufs;        /* Number of interrupt buffers to allocate */
  579.  
  580. /* Basic message buffer structure */
  581. struct mbuf {
  582.     struct mbuf *next;    /* Links mbufs belonging to single packets */
  583.     struct mbuf *anext;    /* Links packets on queues */
  584.     int16 size;        /* Size of associated data buffer */
  585.     int refcnt;        /* Reference count */
  586.     struct mbuf *dup;    /* Pointer to duplicated mbuf */
  587.     char *data;        /* Active working pointers */
  588.     int16 cnt;
  589. };
  590. /* In mbuf.c: */
  591. struct mbuf *alloc_mbuf (int16 size);
  592. struct mbuf *free_mbuf (struct mbuf *bp);
  593.  
  594. struct mbuf *ambufw (int16 size);
  595. struct mbuf *copy_p (struct mbuf *bp,int16 cnt);
  596. int16 dup_p (struct mbuf **hp,struct mbuf *bp,int16 offset,int16 cnt);
  597. struct mbuf *free_p (struct mbuf *bp);
  598. int16 len_p (struct mbuf *bp);
  599. void trim_mbuf (struct mbuf **bpp,int16 length);
  600. int write_p (FILE *fp,struct mbuf *bp);
  601.  
  602. struct mbuf *dequeue (struct mbuf **q);
  603. void enqueue (struct mbuf **q,struct mbuf *bp);
  604. void free_q (struct mbuf **q);
  605. int16 len_q (struct mbuf *bp);
  606.  
  607. struct mbuf *qdata (char *data,int16 cnt);
  608. int16 dqdata (struct mbuf *bp,char *buf,unsigned cnt);
  609.  
  610. void append (struct mbuf **bph,struct mbuf *bp);
  611. struct mbuf *pushdown (struct mbuf *bp,int16 size);
  612. int16 pullup (struct mbuf **bph,char *buf,int16 cnt);
  613.  
  614. int pullchar (struct mbuf **bpp);       /* returns -1 if nothing */
  615. long pull16 (struct mbuf **bpp);    /* returns -1 if nothing */
  616. int32 pull32 (struct mbuf **bpp);    /* returns  0 if nothing */
  617.  
  618. int16 get16 (char *cp);
  619. int32 get32 (char *cp);
  620. char *put16 (char *cp,int16 x);
  621. char *put32 (char *cp,int32 x);
  622.  
  623. void iqstat (void);
  624. void refiq (void);
  625. void mbuf_crunch (struct mbuf **bpp);
  626.  
  627. /****************************************************************************
  628. *    timer.h                                                                    *
  629. *    $Id: timer.h 1.2 93/07/16 11:51:38 ROOT_DOS Exp $
  630. *    04 Jul 93    1.2        GT    Fix warnings.                                    *
  631. *
  632. *  ATARI Version by David Nash - dnash@chaos.demon.co.uk
  633. *
  634. *  Adjust MSPTICK and add extern int to Tick, Cfunct
  635. *  pause -> Pause to prevent conflict with Lattice C V5.6
  636. *
  637. ****************************************************************************/
  638.  
  639. /* Software timers
  640.  * There is one of these structures for each simulated timer.
  641.  * Whenever the timer is running, it is on a linked list
  642.  * pointed to by "Timers". The list is sorted in ascending order of
  643.  * expiration, with the first timer to expire at the head. This
  644.  * allows the timer process to avoid having to scan the entire list
  645.  * on every clock tick; once it finds an unexpired timer, it can
  646.  * stop searching.
  647.  *
  648.  * Stopping a timer or letting it expire causes it to be removed
  649.  * from the list. Starting a timer puts it on the list at the right
  650.  * place.
  651.  */
  652. struct timer {
  653.     struct timer *next;    /* Linked-list pointer */
  654.     int32 duration;        /* Duration of timer, in ticks */
  655.     int32 expiration;    /* Clock time at expiration */
  656.     void (*func) (void *);    /* Function to call at expiration */
  657.     void *arg;        /* Arg to pass function */
  658.     char state;        /* Timer state */
  659. };
  660. /* Useful user macros that hide the timer structure internals */
  661. volatile extern int Tick;
  662. extern void (*Cfunc[]) (void);    /* List of clock tick functions */
  663. /* In timer.c: */
  664. void alarm (int32 ms);
  665.  
  666. int Pause (int32 ms);
  667. int32 read_timer (struct timer *t);
  668. void set_timer (struct timer *t,int32 x);
  669. void start_timer (struct timer *t);
  670. void stop_timer (struct timer *timer);
  671. char *tformat (int32 t);
  672.  
  673. /* In hardware.c: */
  674. int32 msclock (void);
  675. int32 secclock (void);
  676.  
  677. /*
  678.     -----------------------------------------------------
  679.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  680.  
  681.     hide definition of tag iface 
  682.     -----------------------------------------------------
  683. */
  684.  
  685. /****************************************************************************
  686. *    $Id: config.h 1.5 93/07/16 11:43:29 ROOT_DOS Exp $
  687. *    20 May 92    1.2        GT    Dial up stuff only.                                *
  688. *    13 Jul 93    1.3        GT    Disable LZW.                                    *
  689. *                            Disable SLIP.                                    *
  690. ****************************************************************************/
  691.  
  692. /****************************************************************************
  693. *
  694. *    ATARI version by David Nash - dnash@chaos.demon.co.uk
  695. *
  696. ****************************************************************************/
  697.  
  698. /* Software options */
  699. /* Software tuning parameters */
  700. /* Hardware driver options */
  701. /****************************************************************************
  702. *    $Id: filter.h 1.2 93/07/16 11:44:39 ROOT_DOS Exp $
  703. *    14 Jun 93    1.2        GT    Enable ip_filter () prototype.                    *
  704. *
  705. *  ATARI Version by David Nash - dnash@chaos.demon.co.uk
  706. *
  707. *  conditionally include ip.h
  708. *
  709. ****************************************************************************/
  710. /*
  711.     -----------------------------------------------------
  712.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  713.  
  714.     __asm added for lcsum prototype
  715.     -----------------------------------------------------
  716. */
  717.  
  718. /* Global structures and constants pertaining to the interface between IP and
  719.  *     higher level protocols
  720.  */
  721.  
  722. /* IP protocol field values */
  723. /* DoD-style precedences */
  724. /* Amateur-style precedences */
  725. /* Class-of-service bits */
  726. /* IP TOS fields */
  727. /* Pseudo-header for TCP and UDP checksumming */
  728. struct pseudo_header {
  729.     int32 source;        /* IP source */
  730.     int32 dest;        /* IP destination */
  731.     char protocol;        /* Protocol */
  732.     int16 length;        /* Data field length */
  733. };
  734. /* Format of a MIB entry for statistics gathering */
  735. struct mib_entry {
  736.     char *name;
  737.     union {
  738.         int32 integer;
  739.     } value;
  740. };
  741.  
  742. extern char Hashtab[];    /* Modulus lookup table */
  743.  
  744. /* SNMP MIB variables, used for statistics and control. See RFC 1066 */
  745. extern struct mib_entry Ip_mib[];
  746. /* IP header, INTERNAL representation */
  747. struct ip {
  748.     int32 source;        /* Source address */
  749.     int32 dest;        /* Destination address */
  750.     int16 length;        /* Total length */
  751.     int16 id;        /* Identification */
  752.     int16 offset;        /* Fragment offset in bytes */
  753.     int16 checksum;        /* Header checksum */
  754.  
  755.     struct {
  756.         char congest;    /* Congestion experienced bit (exp) */
  757.         char df;    /* Don't fragment flag */
  758.         char mf;    /* More Fragments flag */
  759.     } flags;
  760.  
  761.     char version;        /* IP version number */
  762.     char tos;        /* Type of service */
  763.     char ttl;        /* Time to live */
  764.     char protocol;        /* Protocol */
  765.     char optlen;        /* Length of options field, bytes */
  766.     char options[40];/* Options field */
  767. };
  768. /* Fields in option type byte */
  769. /* IP option numbers */
  770. /* Timestamp option flags */
  771. /* IP routing table entry */
  772. struct route {
  773.     struct route *prev;    /* Linked list pointers */
  774.     struct route *next;
  775.     int32 target;        /* Target IP address */
  776.     unsigned int bits;    /* Number of significant bits in target */
  777.     int32 gateway;        /* IP address of local gateway for this target */
  778.     int32 metric;        /* Hop count or whatever */
  779.     struct iface *iface;    /* Device interface structure */
  780.     int flags;
  781.     struct timer timer;    /* Time until aging of this entry */
  782.     int32 uses;        /* Usage count */
  783. };
  784. extern struct route *Routes[32][7];    /* Routing table */
  785. extern struct route R_default;            /* Default route entry */
  786.  
  787. /* Cache for the last-used routing entry, speeds up the common case where
  788.  * we handle a burst of packets to the same destination
  789.  */
  790. struct rt_cache {
  791.     int32 target;
  792.     struct route *route;
  793. };
  794. extern struct rt_cache Rt_cache;
  795.  
  796. /* Reassembly descriptor */
  797. struct reasm {
  798.     struct reasm *next;    /* Linked list pointer */
  799.     struct timer timer;    /* Reassembly timeout timer */
  800.     struct frag *fraglist;    /* Head of data fragment chain */
  801.     int16 length;        /* Entire datagram length, if known */
  802.     int32 source;        /* src/dest/id/protocol uniquely describe a datagram */
  803.     int32 dest;
  804.     int16 id;
  805.     char protocol;
  806. };
  807. /* Fragment descriptor in a reassembly list */
  808. struct frag {
  809.     struct frag *prev;    /* Previous fragment on list */
  810.     struct frag *next;    /* Next fragment */
  811.     struct mbuf *buf;    /* Actual fragment data */
  812.     int16 offset;        /* Starting offset of fragment */
  813.     int16 last;        /* Ending offset of fragment */
  814. };
  815. extern struct reasm *Reasmq;    /* The list of reassembly descriptors */
  816.  
  817. /* Structure for handling raw IP user sockets */
  818. struct raw_ip {
  819.     struct raw_ip *next;    /* Linked list pointer */
  820.  
  821.     struct mbuf *rcvq;    /* receive queue */
  822.     void (*r_upcall) (struct raw_ip *);
  823.     int protocol;        /* Protocol */
  824.     int user;        /* User linkage */
  825. };
  826. extern struct raw_ip *Raw_ip;
  827.  
  828. /* Transport protocol link table */
  829. struct iplink {
  830.     char proto;
  831.     void (*funct) (struct iface *,struct ip *,struct mbuf *,int);
  832. };
  833. extern struct iplink Iplink[];
  834.  
  835. /* In ip.c: */
  836. void ip_garbage (int drastic);
  837.  
  838. (struct iface *iface,struct ip *ip,struct mbuf *bp, int rxbroadcast);
  839.  
  840. (struct iface *iface,struct ip *ip,struct mbuf *bp, int rxbroadcast);
  841.  
  842. (int32 source,int32 dest,char protocol,char tos,char ttl, struct mbuf *bp,int16 length,int16 id,char df);
  843. struct raw_ip *raw_ip (int protocol,void (*r_upcall) (struct raw_ip *) );
  844. void del_ip (struct raw_ip *rrp);
  845.  
  846. /* In iproute.c: */
  847. void ipinit (void);
  848. int16 ip_mtu (int32 addr);
  849.  
  850. (struct mbuf *bp,struct iface *iface,int32 gateway, int prec,int del,int tput,int rel);
  851. int ip_route (struct iface *i_iface,struct mbuf *bp,int rxbroadcast);
  852. int32 locaddr (int32 addr);
  853. void rt_merge (int trace);
  854.  
  855. (int32 target,unsigned int bits,int32 gateway, struct iface *iface,int32 metric,int32 ttl,char private);
  856. int rt_drop (int32 target,unsigned int bits);
  857. struct route *rt_lookup (int32 target);
  858. struct route *rt_blookup (int32 target,unsigned int bits);
  859.  
  860. /* In iphdr.c: */
  861. int16 cksum (struct pseudo_header *ph,struct mbuf *m,int16 len);
  862. int16 eac (int32 sum);
  863. struct mbuf *htonip (struct ip *ip,struct mbuf *data,int cflag);
  864. int ntohip (struct ip *ip,struct mbuf **bpp);
  865.  
  866. /* In either lcsum.c or pcgen.asm: */
  867. int16 __asm lcsum(int16 *wp, int16 len);
  868. /*
  869.  *   Filter entry structure.
  870.  */
  871. struct filter {
  872.     struct filter    *next;        /* Link to next filter element    */
  873.     short        action;        /* Filter entry match action    */
  874.     int        (*type) (struct mbuf *bp, struct ip *ip, struct filter *fp);    /* Packet type comparison f(x)    */
  875.     struct filtersd {
  876.           unsigned long addr;    /* Address used for comparisons    */
  877.         unsigned long mask;    /* Address comparison mask    */
  878.         unsigned char bits;    /* One bits in high part of mask*/
  879.         unsigned char exclude;    /* Exclude matching addresses    */
  880.         unsigned short port;    /* TCP/UDP port (low of range)    */
  881.         unsigned short hiport;    /* High port of range        */
  882.     } src, dest;
  883.     unsigned long    matches;    /* Number of matching packets    */
  884. };
  885.  
  886. int doipfilter ( int argc, char *argv[], void *p );
  887. int ip_filter ( struct mbuf *bp, struct ip *ip, struct filter *fp );
  888.  
  889. /**
  890.  * $Id: setjmp.h,v 1.2 1993/11/14 14:43:52 AGK Rel $
  891.  *
  892.  * ANSI/POSIX.1 non-local jumps
  893.  *
  894.  * (c) Copyright 1992, 1993 HiSoft
  895. **/
  896.  
  897. typedef struct {long __jmp_buf[13];} jmp_buf[1];
  898.  
  899. void (longjmp)(jmp_buf,int);
  900. int (setjmp)(jmp_buf);
  901. typedef struct {long __sigjmp_buf[13 + (sizeof(__sigset_t) / sizeof(long))];} sigjmp_buf[1];
  902.  
  903. void (siglongjmp)(sigjmp_buf, int);
  904. int (sigsetjmp)(sigjmp_buf, int);
  905. /* Kernel process control block */
  906. struct proc {
  907.     struct proc *prev;    /* Process table pointers */
  908.     struct proc *next;    
  909.  
  910.     jmp_buf env;        /* Process state */
  911.     char i_state;        /* Process interrupt state */
  912.  
  913.     unsigned short state;
  914.     void *event;        /* Wait event */
  915.     int16 *stack;        /* Process stack */
  916.     unsigned stksize;    /* Size of same */
  917.     char *name;        /* Arbitrary user-assigned name */
  918.     int retval;        /* Return value from next pwait() */
  919.     struct timer alarm;    /* Alarm clock timer */
  920.     struct mbuf *outbuf;    /* Terminal output buffer */
  921.     int input;        /* standard input socket */
  922.     int output;        /* standard output socket */
  923.     int iarg;        /* Copy of iarg */
  924.     void *parg1;        /* Copy of parg1 */
  925.     void *parg2;        /* Copy of parg2 */
  926.     int freeargs;        /* Free args on termination if set */
  927. };
  928. extern struct proc *Waittab[];    /* Head of wait list */
  929. extern struct proc *Rdytab;    /* Head of ready list */
  930. extern struct proc *Curproc;    /* Currently running process */
  931. extern struct proc *Susptab;    /* Suspended processes */
  932. extern int Stkchk;        /* Stack checking flag */
  933.  
  934. /* In  kernel.c: */
  935. void alert (struct proc *pp,int val);
  936. void chname (struct proc *pp,char *newname);
  937. void killproc (struct proc *pp);
  938. void killself (void);
  939. struct proc *mainproc (char *name);
  940.  
  941. (char *name,unsigned int stksize, void (*pc) (int,void *,void *), int iarg,void *parg1,void *parg2,int freeargs);
  942. int psignal (void *event,int n);
  943. int pwait (void *event);
  944. void resume (struct proc *pp);
  945. void suspend (struct proc *pp);
  946.  
  947. /* In ksubr.c: */
  948. void chkstk (void);
  949. void kinit (void);
  950. unsigned phash (void *event);
  951.  
  952. (struct proc *pp,int iarg,void *parg1,void *parg2, void ((*pc) (int,void *,void *) ) );
  953. /* Stack background fill value for high water mark checking */
  954. /* Value stashed in location 0 to detect null pointer dereferences */
  955. /* Interface encapsulation mode table entry. An array of these structures
  956.  * are initialized in config.c with all of the information necessary
  957.  * to attach a device.
  958.  */
  959.  
  960. struct iface;    /* ATARI incomplete definition to hide definition of tag iface */
  961. struct iftype {
  962.     char *name;        /* Name of encapsulation technique */
  963.     int (*send) (struct mbuf *,struct iface *,int32,int,int,int,int);
  964.                 /* Routine to send an IP datagram */
  965.     int (*output) (struct iface *,char *,char *,int16,struct mbuf *);
  966.                 /* Routine to send link packet */
  967.     char *(*format) (char *,char *);
  968.                 /* Function that formats addresses */
  969.     int (*scan) (char *,char *);
  970.                 /* Reverse of format */
  971.     int type;        /* Type field for network process */
  972.     int hwalen;        /* Length of hardware address, if any */
  973. };
  974. extern struct iftype Iftypes[];
  975.  
  976.  
  977. /* Interface control structure */
  978. struct iface {
  979.     struct iface *next;    /* Linked list pointer */
  980.     char *name;        /* Ascii string with interface name */
  981.  
  982.     int32 addr;        /* IP address */
  983.     int32 broadcast;    /* Broadcast address */
  984.     int32 netmask;        /* Network mask */
  985.  
  986.     int16 mtu;        /* Maximum transmission unit size */
  987.  
  988.     int16 flags;        /* Configuration flags */
  989.     int16 trace;        /* Trace flags */
  990.     char *trfile;        /* Trace file name, if any */
  991.     FILE *trfp;        /* Stream to trace to */
  992.  
  993.     struct iface *forw;    /* Forwarding interface for output, if rx only */
  994.  
  995.     struct proc *rxproc;    /* Receiver process, if any */
  996.     struct proc *txproc;    /* Transmitter process, if any */
  997.     struct proc *supv;    /* Supervisory process, if any */
  998.  
  999.     /* Filter specifications */
  1000.     struct filter *infilter;  /* Inbound filter */
  1001.     struct filter *outfilter; /* Outbound filter */
  1002.     /* Device dependant */
  1003.     int dev;        /* Subdevice number to pass to send */
  1004.                 /* To device -- control */
  1005.     int32 (*ioctl) (struct iface *,int cmd,int set,int32 val);
  1006.                 /* From device -- when status changes */
  1007.     int (*iostatus) (struct iface *,int cmd,int32 val);
  1008.                 /* Call before detaching */
  1009.     int (*stop) (struct iface *);
  1010.     char *hwaddr;        /* Device hardware address, if any */
  1011.  
  1012.     /* Encapsulation dependant */
  1013.     void *edv;        /* Pointer to protocol extension block, if any */
  1014.     int type;        /* Link header type for phdr */
  1015.     int xdev;        /* Associated Slip or Nrs channel, if any */
  1016.     struct iftype *iftype;    /* Pointer to appropriate iftype entry */
  1017.  
  1018.             /* Encapsulate an IP datagram */
  1019.     int (*send) (struct mbuf *,struct iface *,int32,int,int,int,int);
  1020.             /* Encapsulate any link packet */
  1021.     int (*output) (struct iface *,char *,char *,int16,struct mbuf *);
  1022.             /* Send raw packet */
  1023.     int (*raw)        (struct iface *,struct mbuf *);
  1024.             /* Display status */
  1025.     void (*show)        (struct iface *);
  1026.  
  1027.     int (*discard)        (struct iface *,struct mbuf *);
  1028.     int (*echo)        (struct iface *,struct mbuf *);
  1029.  
  1030.     /* Counters */
  1031.     int32 ipsndcnt;     /* IP datagrams sent */
  1032.     int32 rawsndcnt;    /* Raw packets sent */
  1033.     int32 iprecvcnt;    /* IP datagrams received */
  1034.     int32 rawrecvcnt;    /* Raw packets received */
  1035.     int32 lastsent;        /* Clock time of last send */
  1036.     int32 lastrecv;        /* Clock time of last receive */
  1037.  
  1038.     /* Demand dial */
  1039.     int    dial_me;        /* !0 means demand dial */
  1040. };
  1041. extern struct iface *Ifaces;    /* Head of interface list */
  1042. extern struct iface  Loopback;    /* Optional loopback interface */
  1043. extern struct iface  Encap;    /* IP-in-IP pseudo interface */
  1044.  
  1045. /* Header put on front of each packet in input queue */
  1046. struct phdr {
  1047.     struct iface *iface;
  1048.     unsigned short type;    /* Use pktdrvr "class" values */
  1049. };
  1050. extern char Noipaddr[];
  1051. extern struct mbuf *Hopper;
  1052.  
  1053. /* In iface.c: */
  1054. struct iface *if_lookup (char *name);
  1055. struct iface *ismyaddr (int32 addr);
  1056. int if_detach (struct iface *ifp);
  1057. int setencap (struct iface *ifp,char *mode);
  1058. char *if_name (struct iface *ifp,char *comment);
  1059. int bitbucket (struct iface *ifp,struct mbuf *bp);
  1060.  
  1061. /* In config.c: */
  1062. int net_route (struct iface *ifp,int type,struct mbuf *bp);
  1063.  
  1064. /* Generic Ethernet constants and templates */
  1065. /* Format of an Ethernet header */
  1066. struct ether {
  1067.     char dest[6];
  1068.     char source[6];
  1069.     int16 type;
  1070. };
  1071. /* Ethernet broadcast address */
  1072. extern char Ether_bdcst[];
  1073.  
  1074. /* Ethernet type fields */
  1075. /* In file enet.c: */
  1076. char *pether (char *out,char *addr);
  1077. int gether (char *out,char *cp);
  1078.  
  1079. (struct mbuf *bp,struct iface *iface,int32 gateway,int prec, int del,int tput,int rel);
  1080.  
  1081. (struct iface *iface,char dest[],char source[],int16 type, struct mbuf *data);
  1082. void eproc (struct iface *iface,struct mbuf *bp);
  1083.  
  1084. /* In enethdr.c: */
  1085. struct mbuf *htonether (struct ether *ether,struct mbuf *data);
  1086. int ntohether (struct ether *ether,struct mbuf **bpp);
  1087.  
  1088. /* Berkeley format socket address structures. These things were rather
  1089.  * poorly thought out, but compatibility is important (or so they say).
  1090.  * Note that all the sockaddr variants must be of the same size, 16 bytes
  1091.  * to be specific. Although attempts have been made to account for alignment
  1092.  * requirements (notably in sockaddr_ax), porters should check each
  1093.  * structure.
  1094.  */
  1095.  
  1096. /* Generic socket address structure */
  1097. struct sockaddr {
  1098.     short sa_family;
  1099.     char sa_data[14];
  1100. };
  1101.  
  1102. /* This is a structure for "historical" reasons (whatever they are) */
  1103. struct in_addr {
  1104.     unsigned long s_addr;
  1105. };
  1106.  
  1107. /* Socket address, DARPA Internet style */
  1108. struct sockaddr_in {
  1109.     short sin_family;
  1110.     unsigned short sin_port;
  1111.     struct in_addr sin_addr;
  1112.     char sin_zero[8];
  1113. };
  1114.  
  1115. /* AX.25 datagram (address) sub-layer definitions */
  1116.  
  1117. /* Upper sub-layer (LAPB) definitions */
  1118.  
  1119. /* Control field templates */
  1120. /* FRMR reason bits */
  1121. /* Per-connection link control block
  1122.  * These are created and destroyed dynamically,
  1123.  * and are indexed through a hash table.
  1124.  * One exists for each logical AX.25 Level 2 connection
  1125.  */
  1126. struct ax25_cb {
  1127.     struct ax25_cb *next;        /* Linked list pointer */
  1128.  
  1129.     struct iface *iface;        /* Interface */
  1130.  
  1131.     struct mbuf *txq;        /* Transmit queue */
  1132.     struct mbuf *rxasm;        /* Receive reassembly buffer */
  1133.     struct mbuf *rxq;        /* Receive queue */
  1134.  
  1135.     char local[7];        /* Addresses */
  1136.     char remote[7];
  1137.  
  1138.     struct {
  1139.         char rejsent;        /* REJ frame has been sent */
  1140.         char remotebusy;    /* Remote sent RNR */
  1141.         char rtt_run;        /* Round trip "timer" is running */
  1142.         char retrans;        /* A retransmission has occurred */
  1143.         char clone;        /* Server-type cb, will be cloned */
  1144.     } flags;
  1145.  
  1146.     char reason;            /* Reason for connection closing */
  1147.     char response;            /* Response owed to other end */
  1148.     char vs;            /* Our send state variable */
  1149.     char vr;            /* Our receive state variable */
  1150.     char unack;            /* Number of unacked frames */
  1151.     int maxframe;            /* Transmit flow control level, frames */
  1152.     int16 paclen;            /* Maximum outbound packet size, bytes */
  1153.     int16 window;            /* Local flow control limit, bytes */
  1154.     char proto;            /* Protocol version */
  1155.     int16 pthresh;            /* Poll threshold, bytes */
  1156.     unsigned retries;        /* Retry counter */
  1157.     unsigned n2;            /* Retry limit */
  1158.     int state;            /* Link state */
  1159.     struct timer t1;        /* Retry timer */
  1160.     struct timer t3;        /* Keep-alive poll timer */
  1161.     int32 rtt_time;            /* Stored clock values for RTT, ticks */
  1162.     int rtt_seq;            /* Sequence number being timed */
  1163.     int32 srt;            /* Smoothed round-trip time, ms */
  1164.     int32 mdev;            /* Mean rtt deviation, ms */
  1165.  
  1166.     void (*r_upcall) (struct ax25_cb *,int);    /* Receiver upcall */
  1167.     void (*t_upcall) (struct ax25_cb *,int);    /* Transmit upcall */
  1168.     void (*s_upcall) (struct ax25_cb *,int,int);    /* State change upcall */
  1169.  
  1170.     int user;            /* User pointer */
  1171.  
  1172.     int segremain;            /* Segmenter state */
  1173. };
  1174. extern struct ax25_cb Ax25default,*Ax25_cb;
  1175. extern char *Ax25states[],*Axreasons[];
  1176. extern int32 Axirtt,T3init,Blimit;
  1177. extern int16 N2,Maxframe,Paclen,Pthresh,Axwindow,Axversion;
  1178.  
  1179. /* In lapb.c: */
  1180. void est_link (struct ax25_cb *axp);
  1181. void lapbstate (struct ax25_cb *axp,int s);
  1182. int lapb_input (struct ax25_cb *axp,int cmdrsp,struct mbuf *bp);
  1183. int lapb_output (struct ax25_cb *axp);
  1184. struct mbuf *segmenter (struct mbuf *bp,int16 ssize);
  1185. int sendctl (struct ax25_cb *axp,int cmdrsp,int cmd);
  1186.  
  1187. /* In lapbtimer.c: */
  1188. void pollthem (void *p);
  1189. void recover (void *p);
  1190.  
  1191. /* In ax25subr.c: */
  1192. int16 ftype (int control);
  1193. void lapb_garbage (int drastic);
  1194.  
  1195. /* Bits within SSID field of AX.25 address */
  1196. /* Our AX.25 address */
  1197. extern char Mycall[7];
  1198.  
  1199. /* List of AX.25 multicast addresses, e.g., "QST   -0" in shifted ASCII */
  1200. extern char Ax25multi[][7];
  1201.  
  1202. extern int Digipeat;
  1203. extern int Ax25mbox;
  1204.  
  1205. /* Number of chars in interface field. The involved definition takes possible
  1206.  * alignment requirements into account, since ax25_addr is of an odd size.
  1207.  */
  1208. /* Socket address, AX.25 style */
  1209. struct sockaddr_ax {
  1210.     short sax_family;        /* 2 bytes */
  1211.     char ax25_addr[7];
  1212.     char iface[(sizeof(struct sockaddr) - sizeof(short) - 7)];        /* Interface name */
  1213. };
  1214.  
  1215. /* Internal representation of an AX.25 header */
  1216. struct ax25 {
  1217.     char dest[7];        /* Destination address */
  1218.     char source[7];        /* Source address */
  1219.     char digis[7][7];    /* Digi string */
  1220.     int ndigis;            /* Number of digipeaters */
  1221.     int nextdigi;            /* Index to next digi in chain */
  1222.     int cmdrsp;            /* Command/response */
  1223. };
  1224.  
  1225. /* C-bit stuff */
  1226. /* AX.25 routing table entry */
  1227. struct ax_route {
  1228.     struct ax_route *next;        /* Linked list pointer */
  1229.     char target[7];
  1230.     char digis[7][7];
  1231.     int ndigis;
  1232.     char type;
  1233. };
  1234. extern struct ax_route *Ax_routes;
  1235. extern struct ax_route Ax_default;
  1236.  
  1237. /* AX.25 Level 3 Protocol IDs (PIDs) */
  1238. /* Link quality report packet header, internal format */
  1239. struct lqhdr {
  1240.     int16 version;        /* Version number of protocol */
  1241.     int32    ip_addr;    /* Sending station's IP address */
  1242. };
  1243. /* Link quality entry, internal format */
  1244. struct lqentry {
  1245.     char addr[7];    /* Address of heard station */
  1246.     int32 count;        /* Count of packets heard from that station */
  1247. };
  1248. /* Link quality database record format
  1249.  * Currently used only by AX.25 interfaces
  1250.  */
  1251. struct lq {
  1252.     struct lq *next;
  1253.     char addr[7];    /* Hardware address of station heard */
  1254.     struct iface *iface;    /* Interface address was heard on */
  1255.     int32 ka9q_time;        /* Time station was last heard */
  1256.     int32 currxcnt;    /* Current # of packets heard from this station */
  1257.  
  1258. };
  1259. extern struct lq *Lq;    /* Link quality record headers */
  1260.  
  1261. /* Structure used to keep track of monitored destination addresses */
  1262. struct ld {
  1263.     struct ld *next;    /* Linked list pointers */
  1264.     char addr[7];/* Hardware address of destination overheard */
  1265.     struct iface *iface;    /* Interface address was heard on */
  1266.     int32 ka9q_time;        /* Time station was last mentioned */
  1267.     int32 currxcnt;    /* Current # of packets destined to this station */
  1268. };
  1269. extern struct ld *Ld;    /* Destination address record headers */
  1270.  
  1271. /* Linkage to network protocols atop ax25 */
  1272. struct axlink {
  1273.     int pid;
  1274.  
  1275. (struct iface *,struct ax25_cb *,char *, char *, struct mbuf *,int);
  1276. };
  1277. extern struct axlink Axlink[];
  1278.  
  1279. /* Codes for the open_ax25 call */
  1280. /* In ax25.c: */
  1281. struct ax_route *ax_add (char *,int,char digis[][7],int);
  1282. int ax_drop (char *);
  1283. struct ax_route *ax_lookup (char *);
  1284. void ax_recv (struct iface *,struct mbuf *);
  1285.  
  1286. (struct mbuf *bp,struct iface *iface,int32 gateway,int prec, int del,int tput,int rel);
  1287.  
  1288. (struct iface *iface,char *dest,char *source,int16 pid, struct mbuf *data);
  1289. int sendframe (struct ax25_cb *axp,int cmdrsp,int ctl,struct mbuf *data);
  1290.  
  1291. (struct iface *iface,struct ax25_cb *axp,char *src, char *dest,struct mbuf *bp,int mcast);
  1292.  
  1293. /* In ax25cmd.c: */
  1294. void st_ax25 (struct ax25_cb *axp);
  1295.  
  1296. /* In axhdr.c: */
  1297. struct mbuf *htonax25 (struct ax25 *hdr,struct mbuf *data);
  1298. int ntohax25 (struct ax25 *hdr,struct mbuf **bpp);
  1299.  
  1300. /* In axlink.c: */
  1301. void getlqentry (struct lqentry *ep,struct mbuf **bpp);
  1302. void getlqhdr (struct lqhdr *hp,struct mbuf **bpp);
  1303. void logsrc (struct iface *iface,char *addr);
  1304. void logdest (struct iface *iface,char *addr);
  1305. char *putlqentry (char *cp,char *addr,int32 count);
  1306. char *putlqhdr (char *cp,int16 version,int32 ip_addr);
  1307. struct lq *al_lookup (struct iface *ifp,char *addr,int sort);
  1308.  
  1309. /* In ax25user.c: */
  1310.  
  1311. (struct iface *,char *,char *, int,int16, void (*) (struct ax25_cb *,int), void (*) (struct ax25_cb *,int), void (*) (struct ax25_cb *,int,int), int user);
  1312. struct mbuf *recv_ax25 (struct ax25_cb *axp,int16 cnt);
  1313. int reset_ax25 (struct ax25_cb *axp);
  1314. int send_ax25 (struct ax25_cb *axp,struct mbuf *bp,int pid);
  1315.  
  1316. /* In ax25subr.c: */
  1317. int addreq (char *a,char *b);
  1318. struct ax25_cb *cr_ax25 (char *addr);
  1319. void del_ax25 (struct ax25_cb *axp);
  1320. struct ax25_cb *find_ax25 (char *);
  1321. char *pax25 (char *e,char *addr);
  1322. int setcall (char *out,char *call);
  1323.  
  1324. /* In socket.c: */
  1325. void beac_input (struct iface *iface,char *src,struct mbuf *bp);
  1326. void s_arcall (struct ax25_cb *axp,int cnt);
  1327. void s_ascall (struct ax25_cb *axp,int old,int new);
  1328. void s_atcall (struct ax25_cb *axp,int cnt);
  1329.  
  1330. /*
  1331.     -----------------------------------------------------
  1332.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  1333.  
  1334.     Added #define POST and __stdargs upload
  1335.     -----------------------------------------------------
  1336. */
  1337.  
  1338. /**
  1339.  * $Id: stdio.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  1340.  *
  1341.  * ANSI I/O interface file
  1342.  *
  1343.  * (c) Copyright 1989, 1992, 1993 HiSoft
  1344. **/
  1345.  
  1346. /****************************************************************************
  1347. *    $Id: hardware.h 1.3 93/07/16 11:45:05 ROOT_DOS Exp $
  1348. *    15 Jul 93    1.2        GT    Fix warnings.                                    *
  1349. ****************************************************************************/
  1350.  
  1351. struct stopwatch {
  1352.     long calls;
  1353.     int16 maxval;
  1354.     int16 minval;
  1355. };
  1356. struct screen {
  1357.     char *save;        /* Screen save buffer */
  1358.     int row;        /* Saved cursor location */
  1359.     int col;
  1360. };
  1361. extern struct stopwatch Sw[];
  1362. extern int16 Intstk[];    /* Interrupt stack defined in pcgen.asm */
  1363. extern void (*Shutdown[])();    /* List of functions to call at shutdown */
  1364. extern int Mtasker;    /* Type of multitasker, if any */
  1365.  
  1366. /* In 8250.c: */
  1367. void asytimer (void);
  1368.  
  1369. /* In scc.c: */
  1370. void scctimer (void);
  1371. void sccstop (void);
  1372.  
  1373. /* In pc.c: */
  1374. void newscreen (struct session *sp);
  1375. void freescreen (struct session *sp);
  1376. long bioscnt (void);
  1377. void clrbit (unsigned port,char bits);
  1378. void ctick (void);
  1379. int32 divrem (int32 dividend,int16 divisor);
  1380. void  (*getirq (unsigned int) ) (void);
  1381. int getmask (unsigned irq);
  1382. void ioinit (void);
  1383. void iostop (void);
  1384. void kbint (void);
  1385. int kbread (void);
  1386. int maskoff (unsigned irq);
  1387. int maskon (unsigned irq);
  1388. void pctick (void);
  1389. void setbit (unsigned port,char bits);
  1390. int setirq (unsigned irq,void (*handler) (void));
  1391. void sysreset (void);
  1392. void systick (void);
  1393. void writebit (unsigned port,char mask,int val);
  1394.  
  1395. /* In pcgen.asm: */
  1396. void btick (void);
  1397. void chktasker (void);
  1398. void chtimer (void (*)());
  1399. int32 divrem (int32 dividend,int16 divisor);
  1400. int16 getss (void);
  1401. void giveup (void);
  1402. int kbraw (void);
  1403. int16 longdiv (int16 divisor,int n,int16 *dividend);
  1404. int16 longmul (int16 multiplier,int n,int16 *multiplicand);
  1405. void nullvec (void);
  1406. void uchtimer (void);
  1407. int16 clockbits (void);
  1408.  
  1409. /* In stopwatch.asm: */
  1410. void swstart (void);
  1411. int16 stopval (void);
  1412.  
  1413. /* In sw.c: */
  1414. void swstop (int n);
  1415.  
  1416. /*
  1417.     -----------------------------------------------------
  1418.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  1419.  
  1420.     Added V_BYTE verbosity level
  1421.     -----------------------------------------------------
  1422. */
  1423.  
  1424. /**
  1425.  * $Id: stdio.h,v 1.1 1993/11/14 14:43:52 AGK Rel $
  1426.  *
  1427.  * ANSI I/O interface file
  1428.  *
  1429.  * (c) Copyright 1989, 1992, 1993 HiSoft
  1430. **/
  1431.  
  1432. /* Definitions common to both FTP servers and clients */
  1433. /* In ftpsubr.c: */
  1434. long sendfile (FILE *fp,int s,int mode,int hash);
  1435. long recvfile (FILE *fp,int s,int mode,int hash);
  1436. int isbinary (FILE *fp);
  1437.  
  1438. /* Per-session FTP client control block */
  1439. struct ftpcli {
  1440.     int control;        /* Control socket */
  1441.     int data;        /* Data socket */
  1442.  
  1443.     char state;
  1444. int16 verbose;                /* Transfer verbosity level */
  1445.     int batch;        /* Command batching flag */
  1446.     int abort;        /* Aborted transfer flag */
  1447.     char type;        /* Transfer type */
  1448.     char typesent;        /* Last type command sent to server */
  1449.     int logbsize;        /* Logical byte size for logical type */
  1450.     FILE *fp;        /* File descriptor being transferred */
  1451.  
  1452.     struct session *session;
  1453. };
  1454. /*
  1455.     -----------------------------------------------------
  1456.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  1457.  
  1458.     Added __stdargs to tel_output and ttylhandle
  1459.     -----------------------------------------------------
  1460. */
  1461.  
  1462. /* Telnet command characters */
  1463. /* Telnet options */
  1464. /* Telnet protocol control block */
  1465. struct telnet {
  1466.     char local[6];    /* Local option settings */
  1467.     char remote[6];    /* Remote option settings */
  1468.     struct session *session;    /* Pointer to session structure */
  1469.     char eolmode;        /* Control translation of enter key */
  1470. };
  1471. extern int Refuse_echo;
  1472. extern int Tn_cr_mode;
  1473.  
  1474. /* In telnet.c: */
  1475. int tel_connect (struct session *sp,char *fsocket,int len);
  1476.  
  1477. void __stdargs tel_output (int unused, void *p1, void *p2);
  1478. void tnrecv (struct telnet *tn);
  1479. void doopt (struct telnet *tn,int opt);
  1480. void dontopt (struct telnet *tn,int opt);
  1481. void willopt (struct telnet *tn,int opt);
  1482. void wontopt (struct telnet *tn,int opt);
  1483. void answer (struct telnet *tn,int r1,int r2);
  1484.  
  1485. /* In ttylink.c: */
  1486.  
  1487. void __stdargs ttylhandle(int s, void *unused, void *p);
  1488. struct ttystate {
  1489.     struct mbuf *line;    /* Line buffer */
  1490.     int echo;        /* Keyboard local echoing? */
  1491.     int edit;        /* Local editing? */
  1492.     int crnl;        /* Translate cr to lf? */
  1493. };
  1494.  
  1495. /* Session control structure; only one entry is used at a time */
  1496. struct session {
  1497.     int type;
  1498.     char *name;    /* Name of remote host */
  1499.     union {
  1500.         struct ftpcli *ftp;
  1501.         struct telnet *telnet;
  1502.     } cb;
  1503.     struct proc *proc;    /* Primary session process (e.g., tn recv) */
  1504.     struct proc *proc1;    /* Secondary session process (e.g., tn xmit) */
  1505.     struct proc *proc2;    /* Tertiary session process (e.g., upload) */
  1506.     int s;                /* Primary network socket (control for FTP) */
  1507.     FILE *record;        /* Receive record file */
  1508.     char *rfile;        /* Record file name */
  1509.     FILE *upload;        /* Send file */
  1510.     char *ufile;        /* Upload file name */
  1511.     struct ttystate ttystate;
  1512.     struct screen *screen;
  1513.     int input;            /* Input socket */
  1514.     int output;            /* Output socket */
  1515.     int flowmode;        /* control "more" mode */
  1516.     int row;            /* Rows remaining until "more" */
  1517.     int morewait;        /* Output driver is waiting on us */
  1518.     int cur_pos;        /* Cursor position within input buffer */
  1519. };
  1520. extern char *Sestypes[];
  1521. extern unsigned Nsessions;        /* Maximum number of sessions */
  1522. extern struct session *Sessions;    /* Session descriptors themselves */
  1523. extern struct session *Current;        /* Always points to current session */
  1524. extern struct session *Lastcurr;    /* Last non-command session */
  1525. extern struct session *Command;        /* Pointer to command session */
  1526.  
  1527. /* In session.c: */
  1528. void freesession (struct session *sp);
  1529. struct session *sessptr (char *cp);
  1530. struct session *newsession (char *name,int type);
  1531.  
  1532. void __stdargs upload(int unused, void *sp1, void *p);
  1533. /* In pc.c: */
  1534. void swapscreen (struct session *old,struct session *new);
  1535.  
  1536. extern int16 Lport;
  1537. /* SNMP MIB variables, used for statistics and control. See RFC 1066 */
  1538. extern struct mib_entry Icmp_mib[];
  1539. /* Internet Control Message Protocol */
  1540.  
  1541. /* Message types */
  1542. /* Internal format of an ICMP header (checksum is missing) */
  1543. struct icmp {
  1544.     char type;
  1545.     char code;
  1546.      union icmp_args {
  1547.         int16 mtu;
  1548.         int32 unused;
  1549.         unsigned char pointer;
  1550.         int32 address;
  1551.         struct {
  1552.             int16 id;
  1553.             int16 seq;
  1554.         } echo;
  1555.     } args;
  1556. };
  1557. /* Destination Unreachable codes */
  1558. /* Time Exceeded codes */
  1559. /* Redirect message codes */
  1560. extern int Icmp_trace;
  1561.  
  1562. struct ping {
  1563.     struct session *sp;
  1564.     int32 target;        /* Starting target IP address */
  1565.     int incflag;        /* If true, increment target after each ping */
  1566.     int32 sent;        /* Total number of pings sent */
  1567.     int32 srtt;        /* Smoothed round trip time */
  1568.     int32 mdev;        /* Mean deviation */
  1569.     int32 responses;    /* Total number of responses */
  1570.     int32 interval;        /* Inter-ping interval, ticks */
  1571.     int16 len;        /* Length of data portion of ping */
  1572. };
  1573. /* ICMP messages, decoded */
  1574. extern char *Icmptypes[],*Unreach[],*Exceed[],*Redirect[];
  1575.  
  1576. struct icmplink {
  1577.     char proto;
  1578.     void (*funct) (int32,int32,int32,char,char,struct mbuf **);
  1579. };
  1580. extern struct icmplink Icmplink[];
  1581.  
  1582. /* In icmp.c: */
  1583.  
  1584. (struct iface *iface,struct ip *ip,struct mbuf *bp, int rxbroadcast);
  1585.  
  1586. (struct ip *ip,struct mbuf *data,char type,char code, union icmp_args *args);
  1587.  
  1588. /* In icmpcmd.c: */
  1589. void echo_proc (int32 source,int32 dest,struct icmp *icmp,struct mbuf *bp);
  1590. int pingem (int s,int32 target,int16 seq,int16 id,int16 len);
  1591.  
  1592. /* In icmphdr.c: */
  1593. struct mbuf *htonicmp (struct icmp *icmp,struct mbuf *data);
  1594. int ntohicmp (struct icmp *icmp,struct mbuf **bpp);
  1595.  
  1596. /*
  1597.     -----------------------------------------------------
  1598.     ATARI Version by David Nash - dnash@chaos.demon.co.uk
  1599.  
  1600.     __asm added for lcsum prototype
  1601.     -----------------------------------------------------
  1602. */
  1603.  
  1604. /* Lifetime of a valid ARP entry */
  1605. /* Lifetime of a pending ARP entry */
  1606. /* ARP definitions (see RFC 826) */
  1607.  
  1608. /* Address size definitions */
  1609. /* ARP opcodes */
  1610. /* Hardware types */
  1611. extern char *Arptypes[];    /* Type fields in ASCII, defined in arpcmd */
  1612. /* Table of hardware types known to ARP */
  1613. struct arp_type {
  1614.     int16 hwalen;        /* Hardware length */
  1615.     int16 iptype;        /* Hardware type field for IP */
  1616.     int16 arptype;        /* Hardware type field for ARP */
  1617.     int16 pendtime;        /* # secs to wait pending response */
  1618.     char *bdcst;        /* Hardware broadcast address */
  1619.     char *(*format) (char *,char *);
  1620.                 /* Function that formats addresses */
  1621.     int (*scan) (char *,char *);
  1622.                 /* Reverse of format */
  1623. };
  1624. extern struct arp_type Arp_type[];
  1625. /* Format of an ARP request or reply packet. From p. 3 */
  1626. struct arp {
  1627.     int16 hardware;            /* Hardware type */
  1628.     int16 protocol;            /* Protocol type */
  1629.     char hwalen;            /* Hardware address length, bytes */
  1630.     char pralen;            /* Length of protocol address */
  1631.     int16 opcode;            /* ARP opcode (request/reply) */
  1632.     char shwaddr[255];    /* Sender hardware address field */
  1633.     int32 sprotaddr;        /* Sender Protocol address field */
  1634.     char thwaddr[255];    /* Target hardware address field */
  1635.     int32 tprotaddr;        /* Target protocol address field */
  1636. };
  1637.         
  1638. /* Format of ARP table */
  1639. struct arp_tab {
  1640.     struct arp_tab *next;    /* Doubly-linked list pointers */
  1641.     struct arp_tab *prev;    
  1642.     struct timer timer;    /* Time until aging this entry */
  1643.     struct mbuf *pending;    /* Queue of datagrams awaiting resolution */
  1644.     int32 ip_addr;        /* IP Address, host order */
  1645.     int16 hardware;        /* Hardware type */
  1646.     char state;        /* (In)complete */
  1647.     char pub;        /* Respond to requests for this entry? */
  1648.     char *hw_addr;        /* Hardware address */
  1649. };
  1650. extern struct arp_tab *Arp_tab[];
  1651.  
  1652. struct arp_stat {
  1653.     unsigned recv;        /* Total number of ARP packets received */
  1654.     unsigned badtype;    /* Incoming requests for unsupported hardware */
  1655.     unsigned badlen;    /* Incoming length field(s) didn't match types */
  1656.     unsigned badaddr;    /* Bogus incoming addresses */
  1657.     unsigned inreq;        /* Incoming requests for us */
  1658.     unsigned replies;    /* Replies sent */
  1659.     unsigned outreq;    /* Outoging requests sent */
  1660. };
  1661. extern struct arp_stat Arp_stat;
  1662.  
  1663. /* In arp.c: */
  1664.  
  1665. (int32 ipaddr,int16 hardware,char *hw_addr, int pub);
  1666. void arp_drop (void *p);
  1667.  
  1668. (unsigned int hwtype,int hwalen,int iptype,int arptype, int pendtime,char *bdcst,char *(*format) (char *,char *), int (*scan) (char *,char *) );
  1669. void arp_input (struct iface *iface,struct mbuf *bp);
  1670. struct arp_tab *arp_lookup (int16 hardware,int32 ipaddr);
  1671. char *res_arp (struct iface *iface,int16 hardware,int32 target,struct mbuf *bp);
  1672.  
  1673. /* In arphdr.c: */
  1674. struct mbuf *htonarp (struct arp *arp);
  1675. int ntoharp (struct arp *arp,struct mbuf **bpp);
  1676.  
  1677. static void arp_output (struct iface *iface,int16 hardware,int32 target);
  1678.  
  1679. /* Hash table headers */
  1680. struct arp_tab *Arp_tab[7];
  1681.  
  1682. struct arp_stat Arp_stat;
  1683.  
  1684. /* Resolve an IP address to a hardware address; if not found,
  1685.  * initiate query and return NULLCHAR.  If an address is returned, the
  1686.  * interface driver may send the packet; if NULLCHAR is returned,
  1687.  * res_arp() will have saved the packet on its pending queue,
  1688.  * so no further action (like freeing the packet) is necessary.
  1689.  */
  1690. char *res_arp(
  1691.     struct iface *iface,        /* Pointer to interface block */
  1692.     int16 hardware,            /* Hardware type */
  1693.     int32 target,                /* Target IP address */
  1694.     struct mbuf *bp)            /* IP datagram to be queued if unresolved */
  1695. {
  1696.     register struct arp_tab *arp;
  1697.     struct ip ip;
  1698.  
  1699.     if((arp = arp_lookup(hardware,target)) != (struct arp_tab *)0 && arp->state == 1)
  1700.         return arp->hw_addr;
  1701.     if(arp != (struct arp_tab *)0){
  1702.         /* Earlier packets are already pending, kick this one back
  1703.          * as a source quench
  1704.          */
  1705.         ntohip(&ip,&bp);
  1706.         icmp_output(&ip,bp,4,0,((void *) 0));
  1707.         free_p(bp);
  1708.     } else {
  1709.         /* Create an entry and put the datagram on the
  1710.          * queue pending an answer
  1711.          */
  1712.         arp = arp_add(target,hardware,(char *)0,0);
  1713.         enqueue(&arp->pending,bp);
  1714.         arp_output(iface,hardware,target);
  1715.     }
  1716.     return (char *)0;
  1717. }
  1718. /* Handle incoming ARP packets. This is almost a direct implementation of
  1719.  * the algorithm on page 5 of RFC 826, except for:
  1720.  * 1. Outgoing datagrams to unresolved addresses are kept on a queue
  1721.  *    pending a reply to our ARP request.
  1722.  * 2. The names of the fields in the ARP packet were made more mnemonic.
  1723.  * 3. Requests for IP addresses listed in our table as "published" are
  1724.  *    responded to, even if the address is not our own.
  1725.  */
  1726. void
  1727. arp_input(iface,bp)
  1728. struct iface *iface;
  1729. struct mbuf *bp;
  1730. {
  1731.     struct arp arp;
  1732.     struct arp_tab *ap;
  1733.     struct arp_type *at;
  1734.     int i;
  1735.     
  1736.     Arp_stat.recv++;
  1737.     if(ntoharp(&arp,&bp) == -1)    /* Convert into host format */
  1738.         return;
  1739.     if(arp.hardware >= 9){
  1740.         /* Unknown hardware type, ignore */
  1741.         Arp_stat.badtype++;
  1742.         return;
  1743.     }
  1744.     at = &Arp_type[arp.hardware];
  1745.     if(arp.protocol != at->iptype){
  1746.         /* Unsupported protocol type, ignore */
  1747.         Arp_stat.badtype++;
  1748.         return;
  1749.     }
  1750.     if(/*uchar(arp.hwalen) > MAXHWALEN ||*/ ((unsigned char)(arp.pralen)) != sizeof(int32)){
  1751.         /* Incorrect protocol addr length (different hw addr lengths
  1752.          * are OK since AX.25 addresses can be of variable length)
  1753.          */
  1754.         Arp_stat.badlen++;
  1755.         return;
  1756.     }
  1757.     if(__builtin_memcmp(arp.shwaddr,at->bdcst,at->hwalen) == 0){
  1758.         /* This guy is trying to say he's got the broadcast address! */
  1759.         Arp_stat.badaddr++;
  1760.         return;
  1761.     }
  1762.     /* If this guy is already in the table, update its entry
  1763.      * unless it's a manual entry (noted by the lack of a timer)
  1764.      */
  1765.     ap = (struct arp_tab *)0;    /* ap plays the role of merge_flag in the spec */
  1766.     if((ap = arp_lookup(arp.hardware,arp.sprotaddr)) != (struct arp_tab *)0 
  1767.      && ((&ap->timer)->duration* 20) != 0){
  1768.         ap = arp_add(arp.sprotaddr,arp.hardware,arp.shwaddr,0);
  1769.     }
  1770.     /* See if we're the address they're looking for */
  1771.     if(ismyaddr(arp.tprotaddr) != (struct iface *)0){
  1772.         if(ap == (struct arp_tab *)0)    /* Only if not already in the table */
  1773.             arp_add(arp.sprotaddr,arp.hardware,arp.shwaddr,0);
  1774.  
  1775.         if(arp.opcode == 1){
  1776.             /* Swap sender's and target's (us) hardware and protocol
  1777.              * fields, and send the packet back as a reply
  1778.              */
  1779.             __builtin_memcpy(arp.thwaddr,arp.shwaddr,(int16)((unsigned char)(arp.hwalen)));
  1780.             /* Mark the end of the sender's AX.25 address
  1781.              * in case he didn't
  1782.              */
  1783.             if(arp.hardware == 3)
  1784.                 arp.thwaddr[((unsigned char)(arp.hwalen))-1] |= 0x01;
  1785.  
  1786.             __builtin_memcpy(arp.shwaddr,iface->hwaddr,at->hwalen);
  1787.             arp.tprotaddr = arp.sprotaddr;
  1788.             arp.sprotaddr = iface->addr;
  1789.             arp.opcode = 2;
  1790.             if((bp = htonarp(&arp)) == (struct mbuf *)0)
  1791.                 return;
  1792.  
  1793.             if(iface->forw != (struct iface *)0)
  1794.                 (*iface->forw->output)(iface->forw,
  1795.                  arp.thwaddr,iface->forw->hwaddr,at->arptype,bp);
  1796.             else 
  1797.                 (*iface->output)(iface,arp.thwaddr,
  1798.                  iface->hwaddr,at->arptype,bp);
  1799.             Arp_stat.inreq++;
  1800.         } else {
  1801.             Arp_stat.replies++;
  1802.         }
  1803.     } else if(arp.opcode == 1 
  1804.      && (ap = arp_lookup(arp.hardware,arp.tprotaddr)) != (struct arp_tab *)0 
  1805.      && ap->pub){
  1806.         /* Otherwise, respond if the guy he's looking for is
  1807.          * published in our table.
  1808.          */
  1809.         __builtin_memcpy(arp.thwaddr,arp.shwaddr,(int16)((unsigned char)(arp.hwalen)));
  1810.         __builtin_memcpy(arp.shwaddr,ap->hw_addr,at->hwalen);
  1811.         arp.tprotaddr = arp.sprotaddr;
  1812.         arp.sprotaddr = ap->ip_addr;
  1813.         arp.opcode = 2;
  1814.         if((bp = htonarp(&arp)) == (struct mbuf *)0)
  1815.             return;
  1816.         if(iface->forw != (struct iface *)0)
  1817.             (*iface->forw->output)(iface->forw,
  1818.              arp.thwaddr,iface->forw->hwaddr,at->arptype,bp);
  1819.         else 
  1820.             (*iface->output)(iface,arp.thwaddr,
  1821.              iface->hwaddr,at->arptype,bp);
  1822.         Arp_stat.inreq++;
  1823.     } else if(arp.opcode == 3){
  1824.         for(i=0;i< 7;i++)
  1825.             for(ap = Arp_tab[i];ap != (struct arp_tab *)0;ap = ap->next)
  1826.                 if(__builtin_memcmp(ap->hw_addr,arp.thwaddr,at->hwalen) == 0)
  1827.                     goto found;
  1828.     found:    if(ap != (struct arp_tab *)0 && ap->pub){
  1829.             __builtin_memcpy(arp.shwaddr,iface->hwaddr,at->hwalen);
  1830.             arp.tprotaddr = ap->ip_addr;
  1831.             arp.sprotaddr = iface->addr;
  1832.             arp.opcode = 4;
  1833.             if((bp = htonarp(&arp)) == (struct mbuf *)0)
  1834.                 return;
  1835.             if(iface->forw != (struct iface *)0)
  1836.                 (*iface->forw->output)(iface->forw,
  1837.                  arp.thwaddr,iface->forw->hwaddr,0x8035,bp);
  1838.             else 
  1839.                 (*iface->output)(iface,arp.thwaddr,
  1840.                  iface->hwaddr,0x8035,bp);
  1841.             Arp_stat.inreq++;
  1842.         }
  1843.     }
  1844. }
  1845. /* Add an IP-addr / hardware-addr pair to the ARP table */
  1846. struct arp_tab *arp_add(
  1847.     int32 ipaddr,                /* IP address, host order */
  1848.     int16 hardware,            /* Hardware type */
  1849.     char *hw_addr,                /* Hardware address, if known; NULLCHAR otherwise */
  1850.     int pub)                        /* Publish this entry? */
  1851. {
  1852.     struct mbuf *bp;
  1853.     register struct arp_tab *ap;
  1854.     struct arp_type *at;
  1855.     unsigned hashval;
  1856.  
  1857.     if(hardware >= 9)
  1858.         return (struct arp_tab *)0;    /* Invalid hardware type */
  1859.     at = &Arp_type[hardware];
  1860.  
  1861.     if((ap = arp_lookup(hardware,ipaddr)) == (struct arp_tab *)0){
  1862.         /* New entry */
  1863.         ap = (struct arp_tab *)callocw(1,sizeof(struct arp_tab));
  1864.         ap->hw_addr = mallocw(at->hwalen);
  1865.         ap->timer.func = arp_drop;
  1866.         ap->timer.arg = ap;
  1867.         ap->hardware = hardware;
  1868.         ap->ip_addr = ipaddr;
  1869.  
  1870.         /* Put on head of hash chain */
  1871.         hashval = hash_ip(ipaddr);
  1872.         ap->prev = (struct arp_tab *)0;
  1873.         ap->next = Arp_tab[hashval];
  1874.         Arp_tab[hashval] = ap;
  1875.         if(ap->next != (struct arp_tab *)0){
  1876.             ap->next->prev = ap;
  1877.         }
  1878.     }
  1879.     if(hw_addr == (char *)0){
  1880.         /* Await response */
  1881.         ap->state = 0;
  1882.         set_timer(&ap->timer,Arp_type[hardware].pendtime * 1000L);
  1883.     } else {
  1884.         /* Response has come in, update entry and run through queue */
  1885.         ap->state = 1;
  1886.         set_timer(&ap->timer,900 *1000L);
  1887.         __builtin_memcpy(ap->hw_addr,hw_addr,at->hwalen);
  1888.         ap->pub = pub;
  1889.         while((bp = dequeue(&ap->pending)) != (struct mbuf *)0)
  1890.             ip_route((struct iface *)0,bp,0);
  1891.     }
  1892.     start_timer(&ap->timer);
  1893.     return ap;
  1894. }
  1895.  
  1896. /* Remove an entry from the ARP table */
  1897. void
  1898. arp_drop(p)
  1899. void *p;
  1900. {
  1901.     register struct arp_tab *ap;
  1902.  
  1903.     ap = (struct arp_tab *)p;
  1904.     if(ap == (struct arp_tab *)0)
  1905.         return;
  1906.     stop_timer(&ap->timer);    /* Shouldn't be necessary */
  1907.     if(ap->next != (struct arp_tab *)0)
  1908.         ap->next->prev = ap->prev;
  1909.     if(ap->prev != (struct arp_tab *)0)
  1910.         ap->prev->next = ap->next;
  1911.     else
  1912.         Arp_tab[hash_ip(ap->ip_addr)] = ap->next;
  1913.     free_q(&ap->pending);
  1914.     free(ap->hw_addr);
  1915.     free((char *)ap);
  1916. }
  1917.  
  1918. /* Look up the given IP address in the ARP table */
  1919. struct arp_tab * arp_lookup(
  1920.     int16 hardware,
  1921.     int32 ipaddr)
  1922. {
  1923.     register struct arp_tab *ap;
  1924.  
  1925.     for(ap = Arp_tab[hash_ip(ipaddr)]; ap != (struct arp_tab *)0; ap = ap->next){
  1926.         if(ap->ip_addr == ipaddr && ap->hardware == hardware)
  1927.             break;
  1928.     }
  1929.     return ap;
  1930. }
  1931. /* Send an ARP request to resolve IP address target_ip */
  1932. static void arp_output(
  1933.     struct iface *iface,
  1934.     int16 hardware,
  1935.     int32 target)
  1936. {
  1937.     struct arp arp;
  1938.     struct mbuf *bp;
  1939.     struct arp_type *at;
  1940.  
  1941.     at = &Arp_type[hardware];
  1942.     if(iface->output == (int (*)())0)
  1943.         return;
  1944.     
  1945.     arp.hardware = hardware;
  1946.     arp.protocol = at->iptype;
  1947.     arp.hwalen = at->hwalen;
  1948.     arp.pralen = sizeof(int32);
  1949.     arp.opcode = 1;
  1950.     __builtin_memcpy(arp.shwaddr,iface->hwaddr,at->hwalen);
  1951.     arp.sprotaddr = iface->addr;
  1952.     __builtin_memset(arp.thwaddr,0,at->hwalen);
  1953.     arp.tprotaddr = target;
  1954.     if((bp = htonarp(&arp)) == (struct mbuf *)0)
  1955.         return;
  1956.     (*iface->output)(iface,at->bdcst,
  1957.         iface->hwaddr,at->arptype,bp);
  1958.     Arp_stat.outreq++;
  1959. }
  1960.  
  1961.